ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಮಾಡ್ಯೂಲ್ ರೆಸಲ್ಯೂಶನ್: ಇಂಪೋರ್ಟ್ ಪಥ ತಂತ್ರಗಳನ್ನು ಸರಳೀಕರಿಸುವುದು

ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನ ಮಾಡ್ಯೂಲ್ ರೆಸಲ್ಯೂಶನ್ ವ್ಯವಸ್ಥೆಯು ಸ್ಕೇಲೆಬಲ್ ಮತ್ತು ನಿರ್ವಹಿಸಬಹುದಾದ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿರ್ಮಿಸುವಲ್ಲಿ ಒಂದು ನಿರ್ಣಾಯಕ ಅಂಶವಾಗಿದೆ. ಇಂಪೋರ್ಟ್ ಪಥಗಳ ಆಧಾರದ ಮೇಲೆ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಮಾಡ್ಯೂಲ್‌ಗಳನ್ನು ಹೇಗೆ ಪತ್ತೆ ಮಾಡುತ್ತದೆ ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ನಿಮ್ಮ ಕೋಡ್‌ಬೇಸ್ ಅನ್ನು ಸಂಘಟಿಸಲು ಮತ್ತು ಸಾಮಾನ್ಯ ತಪ್ಪುಗಳನ್ನು ತಪ್ಪಿಸಲು ಅತ್ಯಗತ್ಯ. ಈ ಸಮಗ್ರ ಮಾರ್ಗದರ್ಶಿಯು ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಮಾಡ್ಯೂಲ್ ರೆಸಲ್ಯೂಶನ್‌ನ ಜಟಿಲತೆಗಳನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ, ಇದರಲ್ಲಿ ಕ್ಲಾಸಿಕ್ ಮತ್ತು ನೋಡ್ ಮಾಡ್ಯೂಲ್ ರೆಸಲ್ಯೂಶನ್ ತಂತ್ರಗಳು, tsconfig.json ನಲ್ಲಿನ baseUrl ಮತ್ತು paths ಪಾತ್ರ, ಮತ್ತು ಇಂಪೋರ್ಟ್ ಪಥಗಳನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ನಿರ್ವಹಿಸಲು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು ಸೇರಿವೆ.

ಮಾಡ್ಯೂಲ್ ರೆಸಲ್ಯೂಶನ್ ಎಂದರೇನು?

ಮಾಡ್ಯೂಲ್ ರೆಸಲ್ಯೂಶನ್ ಎಂದರೆ ನಿಮ್ಮ ಕೋಡ್‌ನಲ್ಲಿನ ಇಂಪೋರ್ಟ್ ಸ್ಟೇಟ್‌ಮೆಂಟ್ ಆಧರಿಸಿ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಕಂಪೈಲರ್ ಒಂದು ಮಾಡ್ಯೂಲ್‌ನ ಸ್ಥಳವನ್ನು ನಿರ್ಧರಿಸುವ ಪ್ರಕ್ರಿಯೆ. ನೀವು import { SomeComponent } from './components/SomeComponent'; ಎಂದು ಬರೆದಾಗ, ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ SomeComponent ಮಾಡ್ಯೂಲ್ ನಿಜವಾಗಿ ನಿಮ್ಮ ಫೈಲ್ ಸಿಸ್ಟಮ್‌ನಲ್ಲಿ ಎಲ್ಲಿದೆ ಎಂದು ಕಂಡುಹಿಡಿಯಬೇಕಾಗುತ್ತದೆ. ಈ ಪ್ರಕ್ರಿಯೆಯು ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಮಾಡ್ಯೂಲ್‌ಗಳನ್ನು ಹೇಗೆ ಹುಡುಕುತ್ತದೆ ಎಂಬುದನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವ ನಿಯಮಗಳು ಮತ್ತು ಕಾನ್ಫಿಗರೇಶನ್‌ಗಳ ಗುಂಪಿನಿಂದ ನಿಯಂತ್ರಿಸಲ್ಪಡುತ್ತದೆ.

ತಪ್ಪಾದ ಮಾಡ್ಯೂಲ್ ರೆಸಲ್ಯೂಶನ್ ಕಂಪೈಲೇಶನ್ ದೋಷಗಳು, ರನ್‌ಟೈಮ್ ದೋಷಗಳು, ಮತ್ತು ಪ್ರಾಜೆಕ್ಟ್‌ನ ರಚನೆಯನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವಲ್ಲಿ ಕಷ್ಟಕ್ಕೆ ಕಾರಣವಾಗಬಹುದು. ಆದ್ದರಿಂದ, ಯಾವುದೇ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಡೆವಲಪರ್‌ಗೆ ಮಾಡ್ಯೂಲ್ ರೆಸಲ್ಯೂಶನ್‌ನ ದೃಢವಾದ ತಿಳುವಳಿಕೆ ಅತ್ಯಗತ್ಯ.

ಮಾಡ್ಯೂಲ್ ರೆಸಲ್ಯೂಶನ್ ತಂತ್ರಗಳು

ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಎರಡು ಪ್ರಮುಖ ಮಾಡ್ಯೂಲ್ ರೆಸಲ್ಯೂಶನ್ ತಂತ್ರಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ, ಇವುಗಳನ್ನು tsconfig.json ನಲ್ಲಿನ moduleResolution ಕಂಪೈಲರ್ ಆಯ್ಕೆಯ ಮೂಲಕ ಕಾನ್ಫಿಗರ್ ಮಾಡಲಾಗುತ್ತದೆ:

• ಕ್ಲಾಸಿಕ್ (Classic): ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಬಳಸುವ ಮೂಲ ಮಾಡ್ಯೂಲ್ ರೆಸಲ್ಯೂಶನ್ ತಂತ್ರ.
• ನೋಡ್ (Node): Node.js ಮಾಡ್ಯೂಲ್ ರೆಸಲ್ಯೂಶನ್ ಅಲ್ಗಾರಿದಮ್ ಅನ್ನು ಅನುಕರಿಸುತ್ತದೆ, ಇದು Node.js ಅನ್ನು ಗುರಿಯಾಗಿಸುವ ಅಥವಾ npm ಪ್ಯಾಕೇಜ್‌ಗಳನ್ನು ಬಳಸುವ ಪ್ರಾಜೆಕ್ಟ್‌ಗಳಿಗೆ ಸೂಕ್ತವಾಗಿದೆ.

ಕ್ಲಾಸಿಕ್ ಮಾಡ್ಯೂಲ್ ರೆಸಲ್ಯೂಶನ್

classic ಮಾಡ್ಯೂಲ್ ರೆಸಲ್ಯೂಶನ್ ತಂತ್ರವು ಎರಡರಲ್ಲಿ ಸರಳವಾದುದು. ಇದು ಮಾಡ್ಯೂಲ್‌ಗಳನ್ನು ನೇರವಾದ ರೀತಿಯಲ್ಲಿ ಹುಡುಕುತ್ತದೆ, ಇಂಪೋರ್ಟ್ ಮಾಡುವ ಫೈಲ್‌ನಿಂದ ಡೈರೆಕ್ಟರಿ ಟ್ರೀಯ ಮೇಲಕ್ಕೆ ಚಲಿಸುತ್ತದೆ.

ಇದು ಹೇಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ:

1. ಇಂಪೋರ್ಟ್ ಮಾಡುವ ಫೈಲ್ ಅನ್ನು ಒಳಗೊಂಡಿರುವ ಡೈರೆಕ್ಟರಿಯಿಂದ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ.
2. ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಹೆಸರು ಮತ್ತು ವಿಸ್ತರಣೆಗಳೊಂದಿಗೆ (.ts, .tsx, .d.ts) ಫೈಲ್‌ಗಾಗಿ ಹುಡುಕುತ್ತದೆ.
3. ಕಂಡುಬರದಿದ್ದರೆ, ಅದು ಪೇರೆಂಟ್ ಡೈರೆಕ್ಟರಿಗೆ ಚಲಿಸುತ್ತದೆ ಮತ್ತು ಹುಡುಕಾಟವನ್ನು ಪುನರಾವರ್ತಿಸುತ್ತದೆ.
4. ಮಾಡ್ಯೂಲ್ ಕಂಡುಬರುವವರೆಗೆ ಅಥವಾ ಫೈಲ್ ಸಿಸ್ಟಮ್‌ನ ರೂಟ್ ತಲುಪುವವರೆಗೆ ಈ ಪ್ರಕ್ರಿಯೆ ಮುಂದುವರಿಯುತ್ತದೆ.

ಉದಾಹರಣೆ:

ಕೆಳಗಿನ ಪ್ರಾಜೆಕ್ಟ್ ರಚನೆಯನ್ನು ಪರಿಗಣಿಸಿ:

project/
├── src/
│   ├── components/
│   │   ├── SomeComponent.ts
│   │   └── index.ts
│   └── app.ts
├── tsconfig.json

ಒಂದು ವೇಳೆ app.ts ಫೈಲ್‌ನಲ್ಲಿ import { SomeComponent } from './components/SomeComponent'; ಇಂಪೋರ್ಟ್ ಸ್ಟೇಟ್‌ಮೆಂಟ್ ಇದ್ದರೆ, classic ಮಾಡ್ಯೂಲ್ ರೆಸಲ್ಯೂಶನ್ ತಂತ್ರವು ಹೀಗೆ ಮಾಡುತ್ತದೆ:

1. src ಡೈರೆಕ್ಟರಿಯಲ್ಲಿ ./components/SomeComponent.ts, ./components/SomeComponent.tsx, ಅಥವಾ ./components/SomeComponent.d.ts ಫೈಲ್‌ಗಾಗಿ ಹುಡುಕುತ್ತದೆ.
2. ಕಂಡುಬರದಿದ್ದರೆ, ಅದು ಪೇರೆಂಟ್ ಡೈರೆಕ್ಟರಿಗೆ (ಪ್ರಾಜೆಕ್ಟ್ ರೂಟ್) ಚಲಿಸುತ್ತದೆ ಮತ್ತು ಹುಡುಕಾಟವನ್ನು ಪುನರಾವರ್ತಿಸುತ್ತದೆ, ಆದರೆ ಈ ಸಂದರ್ಭದಲ್ಲಿ ಕಾಂಪೊನೆಂಟ್ src ಫೋಲ್ಡರ್‌ನಲ್ಲிருப்பதால் ಇದು ಯಶಸ್ವಿಯಾಗುವ ಸಾಧ್ಯತೆ ಕಡಿಮೆ.

ಮಿತಿಗಳು:

• ಸಂಕೀರ್ಣ ಪ್ರಾಜೆಕ್ಟ್ ರಚನೆಗಳನ್ನು ನಿರ್ವಹಿಸುವಲ್ಲಿ ಸೀಮಿತ ನಮ್ಯತೆ.
• node_modules ಒಳಗೆ ಹುಡುಕಲು ಬೆಂಬಲಿಸುವುದಿಲ್ಲ, ಆದ್ದರಿಂದ npm ಪ್ಯಾಕೇಜ್‌ಗಳನ್ನು ಅವಲಂಬಿಸಿರುವ ಪ್ರಾಜೆಕ್ಟ್‌ಗಳಿಗೆ ಇದು ಸೂಕ್ತವಲ್ಲ.
• ದೀರ್ಘವಾದ ಮತ್ತು ಪುನರಾವರ್ತಿತ ರಿಲೇಟಿವ್ ಇಂಪೋರ್ಟ್ ಪಥಗಳಿಗೆ ಕಾರಣವಾಗಬಹುದು.

ಯಾವಾಗ ಬಳಸಬೇಕು:

classic ಮಾಡ್ಯೂಲ್ ರೆಸಲ್ಯೂಶನ್ ತಂತ್ರವು ಸಾಮಾನ್ಯವಾಗಿ ಸರಳ ಡೈರೆಕ್ಟರಿ ರಚನೆ ಮತ್ತು ಬಾಹ್ಯ ಅವಲಂಬನೆಗಳಿಲ್ಲದ ಅತಿ ಚಿಕ್ಕ ಪ್ರಾಜೆಕ್ಟ್‌ಗಳಿಗೆ ಮಾತ್ರ ಸೂಕ್ತವಾಗಿದೆ. ಆಧುನಿಕ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಪ್ರಾಜೆಕ್ಟ್‌ಗಳು ಯಾವಾಗಲೂ node ಮಾಡ್ಯೂಲ್ ರೆಸಲ್ಯೂಶನ್ ತಂತ್ರವನ್ನು ಬಳಸಬೇಕು.

ನೋಡ್ ಮಾಡ್ಯೂಲ್ ರೆಸಲ್ಯೂಶನ್

node ಮಾಡ್ಯೂಲ್ ರೆಸಲ್ಯೂಶನ್ ತಂತ್ರವು Node.js ಬಳಸುವ ಮಾಡ್ಯೂಲ್ ರೆಸಲ್ಯೂಶನ್ ಅಲ್ಗಾರಿದಮ್ ಅನ್ನು ಅನುಕರಿಸುತ್ತದೆ. ಇದು Node.js ಅನ್ನು ಗುರಿಯಾಗಿಸುವ ಅಥವಾ npm ಪ್ಯಾಕೇಜ್‌ಗಳನ್ನು ಬಳಸುವ ಪ್ರಾಜೆಕ್ಟ್‌ಗಳಿಗೆ ಆದ್ಯತೆಯ ಆಯ್ಕೆಯಾಗಿದೆ, ಏಕೆಂದರೆ ಇದು ಸ್ಥಿರ ಮತ್ತು ನಿರೀಕ್ಷಿತ ಮಾಡ್ಯೂಲ್ ರೆಸಲ್ಯೂಶನ್ ನಡವಳಿಕೆಯನ್ನು ಒದಗಿಸುತ್ತದೆ.

ಇದು ಹೇಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ:

node ಮಾಡ್ಯೂಲ್ ರೆಸಲ್ಯೂಶನ್ ತಂತ್ರವು ಹೆಚ್ಚು ಸಂಕೀರ್ಣವಾದ ನಿಯಮಗಳನ್ನು ಅನುಸರಿಸುತ್ತದೆ, node_modules ಒಳಗೆ ಹುಡುಕುವುದಕ್ಕೆ ಆದ್ಯತೆ ನೀಡುತ್ತದೆ ಮತ್ತು ವಿಭಿನ್ನ ಫೈಲ್ ವಿಸ್ತರಣೆಗಳನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ:

1. ನಾನ್-ರಿಲೇಟಿವ್ ಇಂಪೋರ್ಟ್‌ಗಳು: ಇಂಪೋರ್ಟ್ ಪಥವು ./, ../, ಅಥವಾ / ನಿಂದ ಪ್ರಾರಂಭವಾಗದಿದ್ದರೆ, ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಅದು node_modules ನಲ್ಲಿರುವ ಮಾಡ್ಯೂಲ್ ಎಂದು ಭಾವಿಸುತ್ತದೆ. ಇದು ಈ ಕೆಳಗಿನ ಸ್ಥಳಗಳಲ್ಲಿ ಮಾಡ್ಯೂಲ್‌ಗಾಗಿ ಹುಡುಕುತ್ತದೆ:
• ಪ್ರಸ್ತುತ ಡೈರೆಕ್ಟರಿಯಲ್ಲಿನ node_modules.
• ಪೇರೆಂಟ್ ಡೈರೆಕ್ಟರಿಯಲ್ಲಿನ node_modules.
• ...ಮತ್ತು ಹೀಗೆ, ಫೈಲ್ ಸಿಸ್ಟಮ್‌ನ ರೂಟ್ ತಲುಪುವವರೆಗೆ.
2. ರಿಲೇಟಿವ್ ಇಂಪೋರ್ಟ್‌ಗಳು: ಇಂಪೋರ್ಟ್ ಪಥವು ./, ../, ಅಥವಾ / ನಿಂದ ಪ್ರಾರಂಭವಾದರೆ, ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಅದನ್ನು ರಿಲೇಟಿವ್ ಪಥವೆಂದು ಪರಿಗಣಿಸುತ್ತದೆ ಮತ್ತು ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಸ್ಥಳದಲ್ಲಿ ಮಾಡ್ಯೂಲ್‌ಗಾಗಿ ಹುಡುಕುತ್ತದೆ, ಈ ಕೆಳಗಿನವುಗಳನ್ನು ಪರಿಗಣಿಸಿ:
• ಇದು ಮೊದಲು ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಹೆಸರು ಮತ್ತು ವಿಸ್ತರಣೆಗಳೊಂದಿಗೆ (.ts, .tsx, .d.ts) ಫೈಲ್‌ಗಾಗಿ ಹುಡುಕುತ್ತದೆ.
• ಕಂಡುಬರದಿದ್ದರೆ, ಇದು ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಹೆಸರಿನ ಡೈರೆಕ್ಟರಿಗಾಗಿ ಮತ್ತು ಆ ಡೈರೆಕ್ಟರಿಯೊಳಗೆ index.ts, index.tsx, ಅಥವಾ index.d.ts ಹೆಸರಿನ ಫೈಲ್‌ಗಾಗಿ ಹುಡುಕುತ್ತದೆ (ಉದಾಹರಣೆಗೆ, ಇಂಪೋರ್ಟ್ ./components ಆಗಿದ್ದರೆ ./components/index.ts).

ಉದಾಹರಣೆ:

lodash ಲೈಬ್ರರಿಯ ಮೇಲೆ ಅವಲಂಬನೆಯನ್ನು ಹೊಂದಿರುವ ಕೆಳಗಿನ ಪ್ರಾಜೆಕ್ಟ್ ರಚನೆಯನ್ನು ಪರಿಗಣಿಸಿ:

project/
├── src/
│   ├── utils/
│   │   └── helpers.ts
│   └── app.ts
├── node_modules/
│   └── lodash/
│       └── lodash.js
├── tsconfig.json

ಒಂದು ವೇಳೆ app.ts ಫೈಲ್‌ನಲ್ಲಿ import * as _ from 'lodash'; ಇಂಪೋರ್ಟ್ ಸ್ಟೇಟ್‌ಮೆಂಟ್ ಇದ್ದರೆ, node ಮಾಡ್ಯೂಲ್ ರೆಸಲ್ಯೂಶನ್ ತಂತ್ರವು ಹೀಗೆ ಮಾಡುತ್ತದೆ:

1. lodash ನಾನ್-ರಿಲೇಟಿವ್ ಇಂಪೋರ್ಟ್ ಎಂದು ಗುರುತಿಸುತ್ತದೆ.
2. ಪ್ರಾಜೆಕ್ಟ್ ರೂಟ್‌ನೊಳಗಿನ node_modules ಡೈರೆಕ್ಟರಿಯಲ್ಲಿ lodash ಗಾಗಿ ಹುಡುಕುತ್ತದೆ.
3. node_modules/lodash/lodash.js ನಲ್ಲಿ lodash ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಹುಡುಕುತ್ತದೆ.

ಒಂದು ವೇಳೆ helpers.ts ಫೈಲ್‌ನಲ್ಲಿ import { SomeHelper } from './SomeHelper'; ಇಂಪೋರ್ಟ್ ಸ್ಟೇಟ್‌ಮೆಂಟ್ ಇದ್ದರೆ, node ಮಾಡ್ಯೂಲ್ ರೆಸಲ್ಯೂಶನ್ ತಂತ್ರವು ಹೀಗೆ ಮಾಡುತ್ತದೆ:

1. ./SomeHelper ಒಂದು ರಿಲೇಟಿವ್ ಇಂಪೋರ್ಟ್ ಎಂದು ಗುರುತಿಸುತ್ತದೆ.
2. src/utils ಡೈರೆಕ್ಟರಿಯಲ್ಲಿ ./SomeHelper.ts, ./SomeHelper.tsx, ಅಥವಾ ./SomeHelper.d.ts ಫೈಲ್‌ಗಾಗಿ ಹುಡುಕುತ್ತದೆ.
3. ಆ ಫೈಲ್‌ಗಳು ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲದಿದ್ದರೆ, ಅದು SomeHelper ಹೆಸರಿನ ಡೈರೆಕ್ಟರಿಗಾಗಿ ಮತ್ತು ನಂತರ ಆ ಡೈರೆಕ್ಟರಿಯೊಳಗೆ index.ts, index.tsx, ಅಥವಾ index.d.ts ಗಾಗಿ ಹುಡುಕುತ್ತದೆ.

ಪ್ರಯೋಜನಗಳು:

• node_modules ಮತ್ತು npm ಪ್ಯಾಕೇಜ್‌ಗಳನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ.
• Node.js ನೊಂದಿಗೆ ಸ್ಥಿರವಾದ ಮಾಡ್ಯೂಲ್ ರೆಸಲ್ಯೂಶನ್ ನಡವಳಿಕೆಯನ್ನು ಒದಗಿಸುತ್ತದೆ.
• node_modules ನಲ್ಲಿನ ಮಾಡ್ಯೂಲ್‌ಗಳಿಗಾಗಿ ನಾನ್-ರಿಲೇಟಿವ್ ಇಂಪೋರ್ಟ್‌ಗಳನ್ನು ಅನುಮತಿಸುವ ಮೂಲಕ ಇಂಪೋರ್ಟ್ ಪಥಗಳನ್ನು ಸರಳಗೊಳಿಸುತ್ತದೆ.

ಯಾವಾಗ ಬಳಸಬೇಕು:

node ಮಾಡ್ಯೂಲ್ ರೆಸಲ್ಯೂಶನ್ ತಂತ್ರವು ಹೆಚ್ಚಿನ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಪ್ರಾಜೆಕ್ಟ್‌ಗಳಿಗೆ ಶಿಫಾರಸು ಮಾಡಲಾದ ಆಯ್ಕೆಯಾಗಿದೆ, ವಿಶೇಷವಾಗಿ Node.js ಅನ್ನು ಗುರಿಯಾಗಿಸುವ ಅಥವಾ npm ಪ್ಯಾಕೇಜ್‌ಗಳನ್ನು ಬಳಸುವ ಪ್ರಾಜೆಕ್ಟ್‌ಗಳಿಗೆ. ಇದು classic ತಂತ್ರಕ್ಕೆ ಹೋಲಿಸಿದರೆ ಹೆಚ್ಚು ನಮ್ಯ ಮತ್ತು ದೃಢವಾದ ಮಾಡ್ಯೂಲ್ ರೆಸಲ್ಯೂಶನ್ ವ್ಯವಸ್ಥೆಯನ್ನು ಒದಗಿಸುತ್ತದೆ.

tsconfig.json ನಲ್ಲಿ ಮಾಡ್ಯೂಲ್ ರೆಸಲ್ಯೂಶನ್ ಅನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡುವುದು

tsconfig.json ಫೈಲ್ ನಿಮ್ಮ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಪ್ರಾಜೆಕ್ಟ್‌ನ ಕೇಂದ್ರ ಕಾನ್ಫಿಗರೇಶನ್ ಫೈಲ್ ಆಗಿದೆ. ಇದು ಮಾಡ್ಯೂಲ್ ರೆಸಲ್ಯೂಶನ್ ತಂತ್ರ ಸೇರಿದಂತೆ ಕಂಪೈಲರ್ ಆಯ್ಕೆಗಳನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಲು ಮತ್ತು ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಹೇಗೆ ನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ಕಸ್ಟಮೈಸ್ ಮಾಡಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.

ಇಲ್ಲಿ node ಮಾಡ್ಯೂಲ್ ರೆಸಲ್ಯೂಶನ್ ತಂತ್ರದೊಂದಿಗೆ ಒಂದು ಮೂಲ tsconfig.json ಫೈಲ್ ಇದೆ:

{
  "compilerOptions": {
    "moduleResolution": "node",
    "target": "es5",
    "module": "commonjs",
    "esModuleInterop": true,
    "strict": true,
    "outDir": "dist",
    "sourceMap": true
  },
  "include": [
    "src/**/*"
  ],
  "exclude": [
    "node_modules"
  ]
}

ಮಾಡ್ಯೂಲ್ ರೆಸಲ್ಯೂಶನ್‌ಗೆ ಸಂಬಂಧಿಸಿದ ಪ್ರಮುಖ compilerOptions:

• moduleResolution: ಮಾಡ್ಯೂಲ್ ರೆಸಲ್ಯೂಶನ್ ತಂತ್ರವನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತದೆ (classic ಅಥವಾ node).
• baseUrl: ನಾನ್-ರಿಲೇಟಿವ್ ಮಾಡ್ಯೂಲ್ ಹೆಸರುಗಳನ್ನು ಪರಿಹರಿಸಲು ಬೇಸ್ ಡೈರೆಕ್ಟರಿಯನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತದೆ.
• paths: ಮಾಡ್ಯೂಲ್‌ಗಳಿಗಾಗಿ ಕಸ್ಟಮ್ ಪಥ ಮ್ಯಾಪಿಂಗ್‌ಗಳನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.

baseUrl ಮತ್ತು paths: ಇಂಪೋರ್ಟ್ ಪಥಗಳನ್ನು ನಿಯಂತ್ರಿಸುವುದು

baseUrl ಮತ್ತು paths ಕಂಪೈಲರ್ ಆಯ್ಕೆಗಳು ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಇಂಪೋರ್ಟ್ ಪಥಗಳನ್ನು ಹೇಗೆ ಪರಿಹರಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ನಿಯಂತ್ರಿಸಲು ಪ್ರಬಲ ಯಾಂತ್ರಿಕತೆಗಳನ್ನು ಒದಗಿಸುತ್ತವೆ. ಅವು ಅಬ್ಸೊಲ್ಯೂಟ್ ಇಂಪೋರ್ಟ್‌ಗಳನ್ನು ಬಳಸಲು ಮತ್ತು ಕಸ್ಟಮ್ ಪಥ ಮ್ಯಾಪಿಂಗ್‌ಗಳನ್ನು ರಚಿಸಲು ಅನುಮತಿಸುವ ಮೂಲಕ ನಿಮ್ಮ ಕೋಡ್‌ನ ಓದುವಿಕೆ ಮತ್ತು ನಿರ್ವಹಣೆಯನ್ನು ಗಮನಾರ್ಹವಾಗಿ ಸುಧಾರಿಸಬಹುದು.

baseUrl

baseUrl ಆಯ್ಕೆಯು ನಾನ್-ರಿಲೇಟಿವ್ ಮಾಡ್ಯೂಲ್ ಹೆಸರುಗಳನ್ನು ಪರಿಹರಿಸಲು ಬೇಸ್ ಡೈರೆಕ್ಟರಿಯನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತದೆ. baseUrl ಅನ್ನು ಹೊಂದಿಸಿದಾಗ, ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಪ್ರಸ್ತುತ ವರ್ಕಿಂಗ್ ಡೈರೆಕ್ಟರಿಯ ಬದಲಿಗೆ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಬೇಸ್ ಡೈರೆಕ್ಟರಿಗೆ ಸಂಬಂಧಿಸಿದಂತೆ ನಾನ್-ರಿಲೇಟಿವ್ ಇಂಪೋರ್ಟ್ ಪಥಗಳನ್ನು ಪರಿಹರಿಸುತ್ತದೆ.

ಉದಾಹರಣೆ:

ಕೆಳಗಿನ ಪ್ರಾಜೆಕ್ಟ್ ರಚನೆಯನ್ನು ಪರಿಗಣಿಸಿ:

project/
├── src/
│   ├── components/
│   │   ├── SomeComponent.ts
│   │   └── index.ts
│   └── app.ts
├── tsconfig.json

ಒಂದು ವೇಳೆ tsconfig.json ಕೆಳಗಿನವುಗಳನ್ನು ಹೊಂದಿದ್ದರೆ:

{
  "compilerOptions": {
    "moduleResolution": "node",
    "baseUrl": "./src"
  }
}

ಆಗ, app.ts ನಲ್ಲಿ, ನೀವು ಈ ಕೆಳಗಿನ ಇಂಪೋರ್ಟ್ ಸ್ಟೇಟ್‌ಮೆಂಟ್ ಅನ್ನು ಬಳಸಬಹುದು:

import { SomeComponent } from 'components/SomeComponent';

ಇದರ ಬದಲಾಗಿ:

import { SomeComponent } from './components/SomeComponent';

ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ baseUrl ನಿಂದ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ./src ಡೈರೆಕ್ಟರಿಗೆ ಸಂಬಂಧಿಸಿದಂತೆ components/SomeComponent ಅನ್ನು ಪರಿಹರಿಸುತ್ತದೆ.

baseUrl ಬಳಸುವುದರ ಪ್ರಯೋಜನಗಳು:

• ಇಂಪೋರ್ಟ್ ಪಥಗಳನ್ನು ಸರಳಗೊಳಿಸುತ್ತದೆ, ವಿಶೇಷವಾಗಿ ಆಳವಾಗಿ ನೆಸ್ಟೆಡ್ ಡೈರೆಕ್ಟರಿಗಳಲ್ಲಿ.
• ಕೋಡ್ ಅನ್ನು ಹೆಚ್ಚು ಓದಬಲ್ಲ ಮತ್ತು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಸುಲಭವಾಗಿಸುತ್ತದೆ.
• ತಪ್ಪಾದ ರಿಲೇಟಿವ್ ಇಂಪೋರ್ಟ್ ಪಥಗಳಿಂದ ಉಂಟಾಗುವ ದೋಷಗಳ ಅಪಾಯವನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ.
• ಇಂಪೋರ್ಟ್ ಪಥಗಳನ್ನು ಭೌತಿಕ ಫೈಲ್ ರಚನೆಯಿಂದ ಬೇರ್ಪಡಿಸುವ ಮೂಲಕ ಕೋಡ್ ರಿಫ್ಯಾಕ್ಟರಿಂಗ್ ಅನ್ನು ಸುಗಮಗೊಳಿಸುತ್ತದೆ.

paths

paths ಆಯ್ಕೆಯು ಮಾಡ್ಯೂಲ್‌ಗಳಿಗಾಗಿ ಕಸ್ಟಮ್ ಪಥ ಮ್ಯಾಪಿಂಗ್‌ಗಳನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ಇದು ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಇಂಪೋರ್ಟ್ ಪಥಗಳನ್ನು ಹೇಗೆ ಪರಿಹರಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ನಿಯಂತ್ರಿಸಲು ಹೆಚ್ಚು ನಮ್ಯ ಮತ್ತು ಪ್ರಬಲವಾದ ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತದೆ, ಮಾಡ್ಯೂಲ್‌ಗಳಿಗೆ ಅಲಿಯಾಸ್‌ಗಳನ್ನು ರಚಿಸಲು ಮತ್ತು ಇಂಪೋರ್ಟ್‌ಗಳನ್ನು ವಿಭಿನ್ನ ಸ್ಥಳಗಳಿಗೆ ಮರುನಿರ್ದೇಶಿಸಲು ನಿಮಗೆ ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.

paths ಆಯ್ಕೆಯು ಒಂದು ಆಬ್ಜೆಕ್ಟ್ ಆಗಿದ್ದು, ಇದರಲ್ಲಿ ಪ್ರತಿಯೊಂದು ಕೀ ಒಂದು ಪಥದ ಮಾದರಿಯನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ, ಮತ್ತು ಪ್ರತಿಯೊಂದು ಮೌಲ್ಯವು ಪಥದ ಬದಲಿಗಳ ಒಂದು ಶ್ರೇಣಿಯಾಗಿದೆ. ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಇಂಪೋರ್ಟ್ ಪಥವನ್ನು ಪಥದ ಮಾದರಿಗಳೊಂದಿಗೆ ಹೊಂದಿಸಲು ಪ್ರಯತ್ನಿಸುತ್ತದೆ ಮತ್ತು ಹೊಂದಾಣಿಕೆಯಾದರೆ, ಇಂಪೋರ್ಟ್ ಪಥವನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಬದಲಿ ಪಥಗಳೊಂದಿಗೆ ಬದಲಾಯಿಸುತ್ತದೆ.

ಉದಾಹರಣೆ:

ಕೆಳಗಿನ ಪ್ರಾಜೆಕ್ಟ್ ರಚನೆಯನ್ನು ಪರಿಗಣಿಸಿ:

project/
├── src/
│   ├── components/
│   │   ├── SomeComponent.ts
│   │   └── index.ts
│   └── app.ts
├── libs/
│   └── my-library.ts
├── tsconfig.json

ಒಂದು ವೇಳೆ tsconfig.json ಕೆಳಗಿನವುಗಳನ್ನು ಹೊಂದಿದ್ದರೆ:

{
  "compilerOptions": {
    "moduleResolution": "node",
    "baseUrl": "./src",
    "paths": {
      "@components/*": ["components/*"],
      "@mylib": ["../libs/my-library.ts"]
    }
  }
}

ಆಗ, app.ts ನಲ್ಲಿ, ನೀವು ಈ ಕೆಳಗಿನ ಇಂಪೋರ್ಟ್ ಸ್ಟೇಟ್‌ಮೆಂಟ್‌ಗಳನ್ನು ಬಳಸಬಹುದು:

import { SomeComponent } from '@components/SomeComponent';
import { MyLibraryFunction } from '@mylib';

ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ @components/* ಪಥ ಮ್ಯಾಪಿಂಗ್ ಆಧರಿಸಿ @components/SomeComponent ಅನ್ನು components/SomeComponent ಗೆ, ಮತ್ತು @mylib ಪಥ ಮ್ಯಾಪಿಂಗ್ ಆಧರಿಸಿ @mylib ಅನ್ನು ../libs/my-library.ts ಗೆ ಪರಿಹರಿಸುತ್ತದೆ.

paths ಬಳಸುವುದರ ಪ್ರಯೋಜನಗಳು:

• ಮಾಡ್ಯೂಲ್‌ಗಳಿಗೆ ಅಲಿಯಾಸ್‌ಗಳನ್ನು ರಚಿಸುತ್ತದೆ, ಇಂಪೋರ್ಟ್ ಪಥಗಳನ್ನು ಸರಳಗೊಳಿಸುತ್ತದೆ ಮತ್ತು ಓದುವಿಕೆಯನ್ನು ಸುಧಾರಿಸುತ್ತದೆ.
• ಇಂಪೋರ್ಟ್‌ಗಳನ್ನು ವಿಭಿನ್ನ ಸ್ಥಳಗಳಿಗೆ ಮರುನಿರ್ದೇಶಿಸುತ್ತದೆ, ಕೋಡ್ ರಿಫ್ಯಾಕ್ಟರಿಂಗ್ ಮತ್ತು ಅವಲಂಬನೆ ನಿರ್ವಹಣೆಯನ್ನು ಸುಗಮಗೊಳಿಸುತ್ತದೆ.
• ಭೌತಿಕ ಫೈಲ್ ರಚನೆಯನ್ನು ಇಂಪೋರ್ಟ್ ಪಥಗಳಿಂದ ಅಮೂರ್ತಗೊಳಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ, ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಬದಲಾವಣೆಗಳಿಗೆ ಹೆಚ್ಚು ಸ್ಥಿತಿಸ್ಥಾಪಕವಾಗಿಸುತ್ತದೆ.
• ನಮ್ಯವಾದ ಪಥ ಹೊಂದಾಣಿಕೆಗಾಗಿ ವೈಲ್ಡ್‌ಕಾರ್ಡ್ ಅಕ್ಷರಗಳನ್ನು (*) ಬೆಂಬಲಿಸುತ್ತದೆ.

paths ಗಾಗಿ ಸಾಮಾನ್ಯ ಬಳಕೆಯ ಪ್ರಕರಣಗಳು:

• ಆಗಾಗ್ಗೆ ಬಳಸುವ ಮಾಡ್ಯೂಲ್‌ಗಳಿಗೆ ಅಲಿಯಾಸ್‌ಗಳನ್ನು ರಚಿಸುವುದು: ಉದಾಹರಣೆಗೆ, ನೀವು ಯುಟಿಲಿಟಿ ಲೈಬ್ರರಿ ಅಥವಾ ಹಂಚಿದ ಕಾಂಪೊನೆಂಟ್‌ಗಳ ಗುಂಪಿಗೆ ಅಲಿಯಾಸ್ ಅನ್ನು ರಚಿಸಬಹುದು.
• ಪರಿಸರವನ್ನು ಆಧರಿಸಿ ವಿಭಿನ್ನ ಅನುಷ್ಠಾನಗಳಿಗೆ ಮ್ಯಾಪಿಂಗ್ ಮಾಡುವುದು: ಉದಾಹರಣೆಗೆ, ನೀವು ಪರೀಕ್ಷಾ ಉದ್ದೇಶಗಳಿಗಾಗಿ ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ಮಾಕ್ ಅನುಷ್ಠಾನಕ್ಕೆ ಮ್ಯಾಪ್ ಮಾಡಬಹುದು.
• ಮೊನೊರೆಪೋಗಳಿಂದ ಇಂಪೋರ್ಟ್‌ಗಳನ್ನು ಸರಳಗೊಳಿಸುವುದು: ಮೊನೊರೆಪೋದಲ್ಲಿ, ನೀವು ವಿಭಿನ್ನ ಪ್ಯಾಕೇಜ್‌ಗಳೊಳಗಿನ ಮಾಡ್ಯೂಲ್‌ಗಳಿಗೆ ಮ್ಯಾಪ್ ಮಾಡಲು paths ಅನ್ನು ಬಳಸಬಹುದು.

ಇಂಪೋರ್ಟ್ ಪಥಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು

ಸ್ಕೇಲೆಬಲ್ ಮತ್ತು ನಿರ್ವಹಿಸಬಹುದಾದ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿರ್ಮಿಸಲು ಇಂಪೋರ್ಟ್ ಪಥಗಳ ಪರಿಣಾಮಕಾರಿ ನಿರ್ವಹಣೆ ಅತ್ಯಗತ್ಯ. ಅನುಸರಿಸಬೇಕಾದ ಕೆಲವು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು ಇಲ್ಲಿವೆ:

• node ಮಾಡ್ಯೂಲ್ ರೆಸಲ್ಯೂಶನ್ ತಂತ್ರವನ್ನು ಬಳಸಿ: node ಮಾಡ್ಯೂಲ್ ರೆಸಲ್ಯೂಶನ್ ತಂತ್ರವು ಹೆಚ್ಚಿನ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಪ್ರಾಜೆಕ್ಟ್‌ಗಳಿಗೆ ಶಿಫಾರಸು ಮಾಡಲಾದ ಆಯ್ಕೆಯಾಗಿದೆ, ಏಕೆಂದರೆ ಇದು ಸ್ಥಿರ ಮತ್ತು ನಿರೀಕ್ಷಿತ ಮಾಡ್ಯೂಲ್ ರೆಸಲ್ಯೂಶನ್ ನಡವಳಿಕೆಯನ್ನು ಒದಗಿಸುತ್ತದೆ.
• baseUrl ಅನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡಿ: ಇಂಪೋರ್ಟ್ ಪಥಗಳನ್ನು ಸರಳಗೊಳಿಸಲು ಮತ್ತು ಓದುವಿಕೆಯನ್ನು ಸುಧಾರಿಸಲು ನಿಮ್ಮ ಸೋರ್ಸ್ ಕೋಡ್‌ನ ರೂಟ್ ಡೈರೆಕ್ಟರಿಗೆ baseUrl ಆಯ್ಕೆಯನ್ನು ಹೊಂದಿಸಿ.
• ಕಸ್ಟಮ್ ಪಥ ಮ್ಯಾಪಿಂಗ್‌ಗಳಿಗಾಗಿ paths ಬಳಸಿ: ಮಾಡ್ಯೂಲ್‌ಗಳಿಗೆ ಅಲಿಯಾಸ್‌ಗಳನ್ನು ರಚಿಸಲು ಮತ್ತು ಇಂಪೋರ್ಟ್‌ಗಳನ್ನು ವಿಭಿನ್ನ ಸ್ಥಳಗಳಿಗೆ ಮರುನಿರ್ದೇಶಿಸಲು paths ಆಯ್ಕೆಯನ್ನು ಬಳಸಿ, ಭೌತಿಕ ಫೈಲ್ ರಚನೆಯನ್ನು ಇಂಪೋರ್ಟ್ ಪಥಗಳಿಂದ ಅಮೂರ್ತಗೊಳಿಸುತ್ತದೆ.
• ಆಳವಾಗಿ ನೆಸ್ಟೆಡ್ ರಿಲೇಟಿವ್ ಇಂಪೋರ್ಟ್ ಪಥಗಳನ್ನು ತಪ್ಪಿಸಿ: ಆಳವಾಗಿ ನೆಸ್ಟೆಡ್ ರಿಲೇಟಿವ್ ಇಂಪೋರ್ಟ್ ಪಥಗಳು (ಉದಾ., ../../../../utils/helpers) ಓದಲು ಮತ್ತು ನಿರ್ವಹಿಸಲು ಕಷ್ಟವಾಗಬಹುದು. ಈ ಪಥಗಳನ್ನು ಸರಳಗೊಳಿಸಲು baseUrl ಮತ್ತು paths ಬಳಸಿ.
• ನಿಮ್ಮ ಇಂಪೋರ್ಟ್ ಶೈಲಿಯೊಂದಿಗೆ ಸ್ಥಿರವಾಗಿರಿ: ಸ್ಥಿರವಾದ ಇಂಪೋರ್ಟ್ ಶೈಲಿಯನ್ನು (ಉದಾ., ಅಬ್ಸೊಲ್ಯೂಟ್ ಇಂಪೋರ್ಟ್‌ಗಳು ಅಥವಾ ರಿಲೇಟಿವ್ ಇಂಪೋರ್ಟ್‌ಗಳನ್ನು ಬಳಸುವುದು) ಆಯ್ಕೆಮಾಡಿ ಮತ್ತು ನಿಮ್ಮ ಪ್ರಾಜೆಕ್ಟ್‌ನಾದ್ಯಂತ ಅದಕ್ಕೆ ಅಂಟಿಕೊಳ್ಳಿ.
• ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಸು-ವ್ಯಾಖ್ಯಾನಿತ ಮಾಡ್ಯೂಲ್‌ಗಳಾಗಿ ಸಂಘಟಿಸಿ: ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಸು-ವ್ಯಾಖ್ಯಾನಿತ ಮಾಡ್ಯೂಲ್‌ಗಳಾಗಿ ಸಂಘಟಿಸುವುದು ಅದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಮತ್ತು ನಿರ್ವಹಿಸಲು ಸುಲಭವಾಗಿಸುತ್ತದೆ, ಮತ್ತು ಇಂಪೋರ್ಟ್ ಪಥಗಳನ್ನು ನಿರ್ವಹಿಸುವ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಸರಳಗೊಳಿಸುತ್ತದೆ.
• ಕೋಡ್ ಫಾರ್ಮ್ಯಾಟರ್ ಮತ್ತು ಲಿಂಟರ್ ಬಳಸಿ: ಕೋಡ್ ಫಾರ್ಮ್ಯಾಟರ್ ಮತ್ತು ಲಿಂಟರ್ ಸ್ಥಿರವಾದ ಕೋಡಿಂಗ್ ಮಾನದಂಡಗಳನ್ನು ಜಾರಿಗೊಳಿಸಲು ಮತ್ತು ನಿಮ್ಮ ಇಂಪೋರ್ಟ್ ಪಥಗಳಲ್ಲಿನ ಸಂಭಾವ್ಯ ಸಮಸ್ಯೆಗಳನ್ನು ಗುರುತಿಸಲು ನಿಮಗೆ ಸಹಾಯ ಮಾಡುತ್ತದೆ.

ಮಾಡ್ಯೂಲ್ ರೆಸಲ್ಯೂಶನ್ ಸಮಸ್ಯೆಗಳನ್ನು ನಿವಾರಿಸುವುದು

ಮಾಡ್ಯೂಲ್ ರೆಸಲ್ಯೂಶನ್ ಸಮಸ್ಯೆಗಳನ್ನು ಡೀಬಗ್ ಮಾಡುವುದು ನಿರಾಶಾದಾಯಕವಾಗಿರುತ್ತದೆ. ಇಲ್ಲಿ ಕೆಲವು ಸಾಮಾನ್ಯ ಸಮಸ್ಯೆಗಳು ಮತ್ತು ಪರಿಹಾರಗಳಿವೆ:

• "Cannot find module" ದೋಷ:
  • ಸಮಸ್ಯೆ: ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಕಂಡುಹಿಡಿಯಲು ಸಾಧ್ಯವಿಲ್ಲ.
  • ಪರಿಹಾರ:
    • ಮಾಡ್ಯೂಲ್ ಇನ್‌ಸ್ಟಾಲ್ ಆಗಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಿ (ಅದು npm ಪ್ಯಾಕೇಜ್ ಆಗಿದ್ದರೆ).
    • ಇಂಪೋರ್ಟ್ ಪಥದಲ್ಲಿ ಟೈಪೊಗಳಿಗಾಗಿ ಪರಿಶೀಲಿಸಿ.
    • tsconfig.json ನಲ್ಲಿ moduleResolution, baseUrl, ಮತ್ತು paths ಆಯ್ಕೆಗಳು ಸರಿಯಾಗಿ ಕಾನ್ಫಿಗರ್ ಆಗಿವೆಯೇ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ.
    • ಮಾಡ್ಯೂಲ್ ಫೈಲ್ ನಿರೀಕ್ಷಿತ ಸ್ಥಳದಲ್ಲಿ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆಯೇ ಎಂದು ದೃಢೀಕರಿಸಿ.
• ತಪ್ಪಾದ ಮಾಡ್ಯೂಲ್ ಆವೃತ್ತಿ:
  • ಸಮಸ್ಯೆ: ನೀವು ಹೊಂದಾಣಿಕೆಯಾಗದ ಆವೃತ್ತಿಯೊಂದಿಗೆ ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಇಂಪೋರ್ಟ್ ಮಾಡುತ್ತಿದ್ದೀರಿ.
  • ಪರಿಹಾರ:
    • ಮಾಡ್ಯೂಲ್‌ನ ಯಾವ ಆವೃತ್ತಿಯು ಇನ್‌ಸ್ಟಾಲ್ ಆಗಿದೆ ಎಂದು ನೋಡಲು ನಿಮ್ಮ package.json ಫೈಲ್ ಅನ್ನು ಪರಿಶೀಲಿಸಿ.
    • ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಹೊಂದಾಣಿಕೆಯಾಗುವ ಆವೃತ್ತಿಗೆ ಅಪ್‌ಡೇಟ್ ಮಾಡಿ.
• ಚಕ್ರೀಯ ಅವಲಂಬನೆಗಳು (Circular dependencies):
  • ಸಮಸ್ಯೆ: ಎರಡು ಅಥವಾ ಹೆಚ್ಚು ಮಾಡ್ಯೂಲ್‌ಗಳು ಒಂದನ್ನೊಂದು ಅವಲಂಬಿಸಿವೆ, ಇದು ಚಕ್ರೀಯ ಅವಲಂಬನೆಯನ್ನು ಸೃಷ್ಟಿಸುತ್ತದೆ.
  • ಪರಿಹಾರ:
    • ಚಕ್ರೀಯ ಅವಲಂಬನೆಯನ್ನು ಮುರಿಯಲು ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ರಿಫ್ಯಾಕ್ಟರ್ ಮಾಡಿ.
    • ಮಾಡ್ಯೂಲ್‌ಗಳನ್ನು ಬೇರ್ಪಡಿಸಲು ಡಿಪೆಂಡೆನ್ಸಿ ಇಂಜೆಕ್ಷನ್ ಬಳಸಿ.

ವಿವಿಧ ಫ್ರೇಮ್‌ವರ್ಕ್‌ಗಳಲ್ಲಿ ನೈಜ-ಪ್ರಪಂಚದ ಉದಾಹರಣೆಗಳು

ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಮಾಡ್ಯೂಲ್ ರೆಸಲ್ಯೂಶನ್‌ನ ತತ್ವಗಳು ವಿವಿಧ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಫ್ರೇಮ್‌ವರ್ಕ್‌ಗಳಲ್ಲಿ ಅನ್ವಯಿಸುತ್ತವೆ. ಅವುಗಳನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ಹೇಗೆ ಬಳಸಲಾಗುತ್ತದೆ ಎಂಬುದು ಇಲ್ಲಿದೆ:

• ರಿಯಾಕ್ಟ್ (React):
  • ರಿಯಾಕ್ಟ್ ಪ್ರಾಜೆಕ್ಟ್‌ಗಳು ಕಾಂಪೊನೆಂಟ್-ಆಧಾರಿತ ಆರ್ಕಿಟೆಕ್ಚರ್ ಮೇಲೆ ಹೆಚ್ಚು ಅವಲಂಬಿತವಾಗಿವೆ, ಆದ್ದರಿಂದ ಸರಿಯಾದ ಮಾಡ್ಯೂಲ್ ರೆಸಲ್ಯೂಶನ್ ಅತ್ಯಗತ್ಯ.
  • src ಡೈರೆಕ್ಟರಿಗೆ ಸೂಚಿಸಲು baseUrl ಅನ್ನು ಬಳಸುವುದು import MyComponent from 'components/MyComponent'; ನಂತಹ ಕ್ಲೀನ್ ಇಂಪೋರ್ಟ್‌ಗಳನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುತ್ತದೆ.
  • styled-components ಅಥವಾ material-ui ನಂತಹ ಲೈಬ್ರರಿಗಳನ್ನು ಸಾಮಾನ್ಯವಾಗಿ node ರೆಸಲ್ಯೂಶನ್ ತಂತ್ರವನ್ನು ಬಳಸಿಕೊಂಡು node_modules ನಿಂದ ನೇರವಾಗಿ ಇಂಪೋರ್ಟ್ ಮಾಡಲಾಗುತ್ತದೆ.
• ಆಂಗ್ಯುಲರ್ (Angular):
  • ಆಂಗ್ಯುಲರ್ CLI baseUrl ಮತ್ತು paths ಸೇರಿದಂತೆ ಸಂವೇದನಾಶೀಲ ಡೀಫಾಲ್ಟ್‌ಗಳೊಂದಿಗೆ tsconfig.json ಅನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಕಾನ್ಫಿಗರ್ ಮಾಡುತ್ತದೆ.
  • ಆಂಗ್ಯುಲರ್ ಮಾಡ್ಯೂಲ್‌ಗಳು ಮತ್ತು ಕಾಂಪೊನೆಂಟ್‌ಗಳನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ಫೀಚರ್ ಮಾಡ್ಯೂಲ್‌ಗಳಾಗಿ ಸಂಘಟಿಸಲಾಗುತ್ತದೆ, ಮಾಡ್ಯೂಲ್‌ಗಳ ಒಳಗೆ ಮತ್ತು ನಡುವೆ ಸರಳೀಕೃತ ಇಂಪೋರ್ಟ್‌ಗಳಿಗಾಗಿ ಪಥ ಅಲಿಯಾಸ್‌ಗಳನ್ನು ಬಳಸಿಕೊಳ್ಳಲಾಗುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, @app/shared ಒಂದು ಹಂಚಿದ ಮಾಡ್ಯೂಲ್ ಡೈರೆಕ್ಟರಿಗೆ ಮ್ಯಾಪ್ ಮಾಡಬಹುದು.
• ವ್ಯೂ.ಜೆಎಸ್ (Vue.js):
  • ರಿಯಾಕ್ಟ್‌ನಂತೆಯೇ, ವ್ಯೂ.ಜೆಎಸ್ ಪ್ರಾಜೆಕ್ಟ್‌ಗಳು ಕಾಂಪೊನೆಂಟ್ ಇಂಪೋರ್ಟ್‌ಗಳನ್ನು ಸುಗಮಗೊಳಿಸಲು baseUrl ಅನ್ನು ಬಳಸುವುದರಿಂದ ಪ್ರಯೋಜನ ಪಡೆಯುತ್ತವೆ.
  • Vuex ಸ್ಟೋರ್ ಮಾಡ್ಯೂಲ್‌ಗಳನ್ನು paths ಬಳಸಿ ಸುಲಭವಾಗಿ ಅಲಿಯಾಸ್ ಮಾಡಬಹುದು, ಕೋಡ್‌ಬೇಸ್‌ನ ಸಂಘಟನೆ ಮತ್ತು ಓದುವಿಕೆಯನ್ನು ಸುಧಾರಿಸುತ್ತದೆ.
• ನೋಡ್.ಜೆಎಸ್ (Node.js) (ಎಕ್ಸ್‌ಪ್ರೆಸ್, ನೆಸ್ಟ್‌ಜೆಎಸ್):
  • ನೆಸ್ಟ್‌ಜೆಎಸ್, ಉದಾಹರಣೆಗೆ, ರಚನಾತ್ಮಕ ಅಪ್ಲಿಕೇಶನ್‌ನಲ್ಲಿ ಮಾಡ್ಯೂಲ್ ಇಂಪೋರ್ಟ್‌ಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಪಥ ಅಲಿಯಾಸ್‌ಗಳನ್ನು ವ್ಯಾಪಕವಾಗಿ ಬಳಸಲು ಪ್ರೋತ್ಸಾಹಿಸುತ್ತದೆ.
  • node ಮಾಡ್ಯೂಲ್ ರೆಸಲ್ಯೂಶನ್ ತಂತ್ರವು ಡೀಫಾಲ್ಟ್ ಆಗಿದೆ ಮತ್ತು node_modules ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಅತ್ಯಗತ್ಯ.

ತೀರ್ಮಾನ

ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನ ಮಾಡ್ಯೂಲ್ ರೆಸಲ್ಯೂಶನ್ ವ್ಯವಸ್ಥೆಯು ನಿಮ್ಮ ಕೋಡ್‌ಬೇಸ್ ಅನ್ನು ಸಂಘಟಿಸಲು ಮತ್ತು ಅವಲಂಬನೆಗಳನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ನಿರ್ವಹಿಸಲು ಒಂದು ಪ್ರಬಲ ಸಾಧನವಾಗಿದೆ. ವಿಭಿನ್ನ ಮಾಡ್ಯೂಲ್ ರೆಸಲ್ಯೂಶನ್ ತಂತ್ರಗಳು, baseUrl ಮತ್ತು paths ನ ಪಾತ್ರ, ಮತ್ತು ಇಂಪೋರ್ಟ್ ಪಥಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ ಮೂಲಕ, ನೀವು ಸ್ಕೇಲೆಬಲ್, ನಿರ್ವಹಿಸಬಹುದಾದ, ಮತ್ತು ಓದಬಲ್ಲ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿರ್ಮಿಸಬಹುದು. tsconfig.json ನಲ್ಲಿ ಮಾಡ್ಯೂಲ್ ರೆಸಲ್ಯೂಶನ್ ಅನ್ನು ಸರಿಯಾಗಿ ಕಾನ್ಫಿಗರ್ ಮಾಡುವುದು ನಿಮ್ಮ ಅಭಿವೃದ್ಧಿ ವರ್ಕ್‌ಫ್ಲೋ ಅನ್ನು ಗಮನಾರ್ಹವಾಗಿ ಸುಧಾರಿಸಬಹುದು ಮತ್ತು ದೋಷಗಳ ಅಪಾಯವನ್ನು ಕಡಿಮೆ ಮಾಡಬಹುದು. ವಿಭಿನ್ನ ಕಾನ್ಫಿಗರೇಶನ್‌ಗಳೊಂದಿಗೆ ಪ್ರಯೋಗ ಮಾಡಿ ಮತ್ತು ನಿಮ್ಮ ಪ್ರಾಜೆಕ್ಟ್‌ನ ಅಗತ್ಯಗಳಿಗೆ ಉತ್ತಮವಾಗಿ ಸರಿಹೊಂದುವ ವಿಧಾನವನ್ನು ಕಂಡುಕೊಳ್ಳಿ.